home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / linux / jiffies.h < prev    next >
C/C++ Source or Header  |  2005-10-13  |  15KB  |  451 lines
  1. #ifndef _LINUX_JIFFIES_H
  2. #define _LINUX_JIFFIES_H
  3.  
  4. #include <linux/kernel.h>
  5. #include <linux/types.h>
  6. #include <linux/time.h>
  7. #include <linux/timex.h>
  8. #include <asm/param.h>            /* for HZ */
  9. #include <asm/div64.h>
  10.  
  11. #ifndef div_long_long_rem
  12. #define div_long_long_rem(dividend,divisor,remainder) \
  13. ({                            \
  14.     __u64 result = dividend;                \
  15.     *remainder = do_div(result,divisor);        \
  16.     result;                        \
  17. })
  18. #endif
  19.  
  20. /*
  21.  * The following defines establish the engineering parameters of the PLL
  22.  * model. The HZ variable establishes the timer interrupt frequency, 100 Hz
  23.  * for the SunOS kernel, 256 Hz for the Ultrix kernel and 1024 Hz for the
  24.  * OSF/1 kernel. The SHIFT_HZ define expresses the same value as the
  25.  * nearest power of two in order to avoid hardware multiply operations.
  26.  */
  27. #if HZ >= 12 && HZ < 24
  28. # define SHIFT_HZ    4
  29. #elif HZ >= 24 && HZ < 48
  30. # define SHIFT_HZ    5
  31. #elif HZ >= 48 && HZ < 96
  32. # define SHIFT_HZ    6
  33. #elif HZ >= 96 && HZ < 192
  34. # define SHIFT_HZ    7
  35. #elif HZ >= 192 && HZ < 384
  36. # define SHIFT_HZ    8
  37. #elif HZ >= 384 && HZ < 768
  38. # define SHIFT_HZ    9
  39. #elif HZ >= 768 && HZ < 1536
  40. # define SHIFT_HZ    10
  41. #else
  42. # error You lose.
  43. #endif
  44.  
  45. /* LATCH is used in the interval timer and ftape setup. */
  46. #define LATCH  ((CLOCK_TICK_RATE + HZ/2) / HZ)    /* For divider */
  47.  
  48. /* Suppose we want to devide two numbers NOM and DEN: NOM/DEN, the we can
  49.  * improve accuracy by shifting LSH bits, hence calculating:
  50.  *     (NOM << LSH) / DEN
  51.  * This however means trouble for large NOM, because (NOM << LSH) may no
  52.  * longer fit in 32 bits. The following way of calculating this gives us
  53.  * some slack, under the following conditions:
  54.  *   - (NOM / DEN) fits in (32 - LSH) bits.
  55.  *   - (NOM % DEN) fits in (32 - LSH) bits.
  56.  */
  57. #define SH_DIV(NOM,DEN,LSH) (   ((NOM / DEN) << LSH)                    \
  58.                              + (((NOM % DEN) << LSH) + DEN / 2) / DEN)
  59.  
  60. /* HZ is the requested value. ACTHZ is actual HZ ("<< 8" is for accuracy) */
  61. #define ACTHZ (SH_DIV (CLOCK_TICK_RATE, LATCH, 8))
  62.  
  63. /* TICK_NSEC is the time between ticks in nsec assuming real ACTHZ */
  64. #define TICK_NSEC (SH_DIV (1000000UL * 1000, ACTHZ, 8))
  65.  
  66. /* TICK_USEC is the time between ticks in usec assuming fake USER_HZ */
  67. #define TICK_USEC ((1000000UL + USER_HZ/2) / USER_HZ)
  68.  
  69. /* TICK_USEC_TO_NSEC is the time between ticks in nsec assuming real ACTHZ and    */
  70. /* a value TUSEC for TICK_USEC (can be set bij adjtimex)        */
  71. #define TICK_USEC_TO_NSEC(TUSEC) (SH_DIV (TUSEC * USER_HZ * 1000, ACTHZ, 8))
  72.  
  73. /* some arch's have a small-data section that can be accessed register-relative
  74.  * but that can only take up to, say, 4-byte variables. jiffies being part of
  75.  * an 8-byte variable may not be correctly accessed unless we force the issue
  76.  */
  77. #define __jiffy_data  __attribute__((section(".data")))
  78.  
  79. /*
  80.  * The 64-bit value is not volatile - you MUST NOT read it
  81.  * without sampling the sequence number in xtime_lock.
  82.  * get_jiffies_64() will do this for you as appropriate.
  83.  */
  84. extern __u64 __jiffy_data jiffies_64;
  85. extern unsigned long volatile __jiffy_data jiffies;
  86.  
  87. #if (BITS_PER_LONG < 64)
  88. __u64 get_jiffies_64(void);
  89. #else
  90. static inline __u64 get_jiffies_64(void)
  91. {
  92.     return (__u64)jiffies;
  93. }
  94. #endif
  95.  
  96. /*
  97.  *    These inlines deal with timer wrapping correctly. You are 
  98.  *    strongly encouraged to use them
  99.  *    1. Because people otherwise forget
  100.  *    2. Because if the timer wrap changes in future you won't have to
  101.  *       alter your driver code.
  102.  *
  103.  * time_after(a,b) returns true if the time a is after time b.
  104.  *
  105.  * Do this with "<0" and ">=0" to only test the sign of the result. A
  106.  * good compiler would generate better code (and a really good compiler
  107.  * wouldn't care). Gcc is currently neither.
  108.  */
  109. #define time_after(a,b)        \
  110.     (typecheck(unsigned long, a) && \
  111.      typecheck(unsigned long, b) && \
  112.      ((long)(b) - (long)(a) < 0))
  113. #define time_before(a,b)    time_after(b,a)
  114.  
  115. #define time_after_eq(a,b)    \
  116.     (typecheck(unsigned long, a) && \
  117.      typecheck(unsigned long, b) && \
  118.      ((long)(a) - (long)(b) >= 0))
  119. #define time_before_eq(a,b)    time_after_eq(b,a)
  120.  
  121. /*
  122.  * Have the 32 bit jiffies value wrap 5 minutes after boot
  123.  * so jiffies wrap bugs show up earlier.
  124.  */
  125. #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
  126.  
  127. /*
  128.  * Change timeval to jiffies, trying to avoid the
  129.  * most obvious overflows..
  130.  *
  131.  * And some not so obvious.
  132.  *
  133.  * Note that we don't want to return MAX_LONG, because
  134.  * for various timeout reasons we often end up having
  135.  * to wait "jiffies+1" in order to guarantee that we wait
  136.  * at _least_ "jiffies" - so "jiffies+1" had better still
  137.  * be positive.
  138.  */
  139. #define MAX_JIFFY_OFFSET ((~0UL >> 1)-1)
  140.  
  141. /*
  142.  * We want to do realistic conversions of time so we need to use the same
  143.  * values the update wall clock code uses as the jiffies size.  This value
  144.  * is: TICK_NSEC (which is defined in timex.h).  This
  145.  * is a constant and is in nanoseconds.  We will used scaled math
  146.  * with a set of scales defined here as SEC_JIFFIE_SC,  USEC_JIFFIE_SC and
  147.  * NSEC_JIFFIE_SC.  Note that these defines contain nothing but
  148.  * constants and so are computed at compile time.  SHIFT_HZ (computed in
  149.  * timex.h) adjusts the scaling for different HZ values.
  150.  
  151.  * Scaled math???  What is that?
  152.  *
  153.  * Scaled math is a way to do integer math on values that would,
  154.  * otherwise, either overflow, underflow, or cause undesired div
  155.  * instructions to appear in the execution path.  In short, we "scale"
  156.  * up the operands so they take more bits (more precision, less
  157.  * underflow), do the desired operation and then "scale" the result back
  158.  * by the same amount.  If we do the scaling by shifting we avoid the
  159.  * costly mpy and the dastardly div instructions.
  160.  
  161.  * Suppose, for example, we want to convert from seconds to jiffies
  162.  * where jiffies is defined in nanoseconds as NSEC_PER_JIFFIE.  The
  163.  * simple math is: jiff = (sec * NSEC_PER_SEC) / NSEC_PER_JIFFIE; We
  164.  * observe that (NSEC_PER_SEC / NSEC_PER_JIFFIE) is a constant which we
  165.  * might calculate at compile time, however, the result will only have
  166.  * about 3-4 bits of precision (less for smaller values of HZ).
  167.  *
  168.  * So, we scale as follows:
  169.  * jiff = (sec) * (NSEC_PER_SEC / NSEC_PER_JIFFIE);
  170.  * jiff = ((sec) * ((NSEC_PER_SEC * SCALE)/ NSEC_PER_JIFFIE)) / SCALE;
  171.  * Then we make SCALE a power of two so:
  172.  * jiff = ((sec) * ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE)) >> SCALE;
  173.  * Now we define:
  174.  * #define SEC_CONV = ((NSEC_PER_SEC << SCALE)/ NSEC_PER_JIFFIE))
  175.  * jiff = (sec * SEC_CONV) >> SCALE;
  176.  *
  177.  * Often the math we use will expand beyond 32-bits so we tell C how to
  178.  * do this and pass the 64-bit result of the mpy through the ">> SCALE"
  179.  * which should take the result back to 32-bits.  We want this expansion
  180.  * to capture as much precision as possible.  At the same time we don't
  181.  * want to overflow so we pick the SCALE to avoid this.  In this file,
  182.  * that means using a different scale for each range of HZ values (as
  183.  * defined in timex.h).
  184.  *
  185.  * For those who want to know, gcc will give a 64-bit result from a "*"
  186.  * operator if the result is a long long AND at least one of the
  187.  * operands is cast to long long (usually just prior to the "*" so as
  188.  * not to confuse it into thinking it really has a 64-bit operand,
  189.  * which, buy the way, it can do, but it take more code and at least 2
  190.  * mpys).
  191.  
  192.  * We also need to be aware that one second in nanoseconds is only a
  193.  * couple of bits away from overflowing a 32-bit word, so we MUST use
  194.  * 64-bits to get the full range time in nanoseconds.
  195.  
  196.  */
  197.  
  198. /*
  199.  * Here are the scales we will use.  One for seconds, nanoseconds and
  200.  * microseconds.
  201.  *
  202.  * Within the limits of cpp we do a rough cut at the SEC_JIFFIE_SC and
  203.  * check if the sign bit is set.  If not, we bump the shift count by 1.
  204.  * (Gets an extra bit of precision where we can use it.)
  205.  * We know it is set for HZ = 1024 and HZ = 100 not for 1000.
  206.  * Haven't tested others.
  207.  
  208.  * Limits of cpp (for #if expressions) only long (no long long), but
  209.  * then we only need the most signicant bit.
  210.  */
  211.  
  212. #define SEC_JIFFIE_SC (31 - SHIFT_HZ)
  213. #if !((((NSEC_PER_SEC << 2) / TICK_NSEC) << (SEC_JIFFIE_SC - 2)) & 0x80000000)
  214. #undef SEC_JIFFIE_SC
  215. #define SEC_JIFFIE_SC (32 - SHIFT_HZ)
  216. #endif
  217. #define NSEC_JIFFIE_SC (SEC_JIFFIE_SC + 29)
  218. #define USEC_JIFFIE_SC (SEC_JIFFIE_SC + 19)
  219. #define SEC_CONVERSION ((unsigned long)((((__u64)NSEC_PER_SEC << SEC_JIFFIE_SC) +\
  220.                                 TICK_NSEC -1) / (__u64)TICK_NSEC))
  221.  
  222. #define NSEC_CONVERSION ((unsigned long)((((__u64)1 << NSEC_JIFFIE_SC) +\
  223.                                         TICK_NSEC -1) / (__u64)TICK_NSEC))
  224. #define USEC_CONVERSION  \
  225.                     ((unsigned long)((((__u64)NSEC_PER_USEC << USEC_JIFFIE_SC) +\
  226.                                         TICK_NSEC -1) / (__u64)TICK_NSEC))
  227. /*
  228.  * USEC_ROUND is used in the timeval to jiffie conversion.  See there
  229.  * for more details.  It is the scaled resolution rounding value.  Note
  230.  * that it is a 64-bit value.  Since, when it is applied, we are already
  231.  * in jiffies (albit scaled), it is nothing but the bits we will shift
  232.  * off.
  233.  */
  234. #define USEC_ROUND (__u64)(((__u64)1 << USEC_JIFFIE_SC) - 1)
  235. /*
  236.  * The maximum jiffie value is (MAX_INT >> 1).  Here we translate that
  237.  * into seconds.  The 64-bit case will overflow if we are not careful,
  238.  * so use the messy SH_DIV macro to do it.  Still all constants.
  239.  */
  240. #if BITS_PER_LONG < 64
  241. # define MAX_SEC_IN_JIFFIES \
  242.     (long)((__u64)((__u64)MAX_JIFFY_OFFSET * TICK_NSEC) / NSEC_PER_SEC)
  243. #else    /* take care of overflow on 64 bits machines */
  244. # define MAX_SEC_IN_JIFFIES \
  245.     (SH_DIV((MAX_JIFFY_OFFSET >> SEC_JIFFIE_SC) * TICK_NSEC, NSEC_PER_SEC, 1) - 1)
  246.  
  247. #endif
  248.  
  249. /*
  250.  * Convert jiffies to milliseconds and back.
  251.  *
  252.  * Avoid unnecessary multiplications/divisions in the
  253.  * two most common HZ cases:
  254.  */
  255. static inline unsigned int jiffies_to_msecs(const unsigned long j)
  256. {
  257. #if HZ <= 1000 && !(1000 % HZ)
  258.     return (1000 / HZ) * j;
  259. #elif HZ > 1000 && !(HZ % 1000)
  260.     return (j + (HZ / 1000) - 1)/(HZ / 1000);
  261. #else
  262.     return (j * 1000) / HZ;
  263. #endif
  264. }
  265.  
  266. static inline unsigned int jiffies_to_usecs(const unsigned long j)
  267. {
  268. #if HZ <= 1000000 && !(1000000 % HZ)
  269.     return (1000000 / HZ) * j;
  270. #elif HZ > 1000000 && !(HZ % 1000000)
  271.     return (j + (HZ / 1000000) - 1)/(HZ / 1000000);
  272. #else
  273.     return (j * 1000000) / HZ;
  274. #endif
  275. }
  276.  
  277. static inline unsigned long msecs_to_jiffies(const unsigned int m)
  278. {
  279.     if (m > jiffies_to_msecs(MAX_JIFFY_OFFSET))
  280.         return MAX_JIFFY_OFFSET;
  281. #if HZ <= 1000 && !(1000 % HZ)
  282.     return (m + (1000 / HZ) - 1) / (1000 / HZ);
  283. #elif HZ > 1000 && !(HZ % 1000)
  284.     return m * (HZ / 1000);
  285. #else
  286.     return (m * HZ + 999) / 1000;
  287. #endif
  288. }
  289.  
  290. static inline unsigned long usecs_to_jiffies(const unsigned int u)
  291. {
  292.     if (u > jiffies_to_usecs(MAX_JIFFY_OFFSET))
  293.         return MAX_JIFFY_OFFSET;
  294. #if HZ <= 1000000 && !(1000000 % HZ)
  295.     return (u + (1000000 / HZ) - 1) / (1000000 / HZ);
  296. #elif HZ > 1000000 && !(HZ % 1000000)
  297.     return u * (HZ / 1000000);
  298. #else
  299.     return (u * HZ + 999999) / 1000000;
  300. #endif
  301. }
  302.  
  303. /*
  304.  * The TICK_NSEC - 1 rounds up the value to the next resolution.  Note
  305.  * that a remainder subtract here would not do the right thing as the
  306.  * resolution values don't fall on second boundries.  I.e. the line:
  307.  * nsec -= nsec % TICK_NSEC; is NOT a correct resolution rounding.
  308.  *
  309.  * Rather, we just shift the bits off the right.
  310.  *
  311.  * The >> (NSEC_JIFFIE_SC - SEC_JIFFIE_SC) converts the scaled nsec
  312.  * value to a scaled second value.
  313.  */
  314. static __inline__ unsigned long
  315. timespec_to_jiffies(const struct timespec *value)
  316. {
  317.     unsigned long sec = value->tv_sec;
  318.     long nsec = value->tv_nsec + TICK_NSEC - 1;
  319.  
  320.     if (sec >= MAX_SEC_IN_JIFFIES){
  321.         sec = MAX_SEC_IN_JIFFIES;
  322.         nsec = 0;
  323.     }
  324.     return (((__u64)sec * SEC_CONVERSION) +
  325.         (((__u64)nsec * NSEC_CONVERSION) >>
  326.          (NSEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
  327.  
  328. }
  329.  
  330. static __inline__ void
  331. jiffies_to_timespec(const unsigned long jiffies, struct timespec *value)
  332. {
  333.     /*
  334.      * Convert jiffies to nanoseconds and separate with
  335.      * one divide.
  336.      */
  337.     __u64 nsec = (__u64)jiffies * TICK_NSEC;
  338.     value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_nsec);
  339. }
  340.  
  341. /* Same for "timeval"
  342.  *
  343.  * Well, almost.  The problem here is that the real system resolution is
  344.  * in nanoseconds and the value being converted is in micro seconds.
  345.  * Also for some machines (those that use HZ = 1024, in-particular),
  346.  * there is a LARGE error in the tick size in microseconds.
  347.  
  348.  * The solution we use is to do the rounding AFTER we convert the
  349.  * microsecond part.  Thus the USEC_ROUND, the bits to be shifted off.
  350.  * Instruction wise, this should cost only an additional add with carry
  351.  * instruction above the way it was done above.
  352.  */
  353. static __inline__ unsigned long
  354. timeval_to_jiffies(const struct timeval *value)
  355. {
  356.     unsigned long sec = value->tv_sec;
  357.     long usec = value->tv_usec;
  358.  
  359.     if (sec >= MAX_SEC_IN_JIFFIES){
  360.         sec = MAX_SEC_IN_JIFFIES;
  361.         usec = 0;
  362.     }
  363.     return (((__u64)sec * SEC_CONVERSION) +
  364.         (((__u64)usec * USEC_CONVERSION + USEC_ROUND) >>
  365.          (USEC_JIFFIE_SC - SEC_JIFFIE_SC))) >> SEC_JIFFIE_SC;
  366. }
  367.  
  368. static __inline__ void
  369. jiffies_to_timeval(const unsigned long jiffies, struct timeval *value)
  370. {
  371.     /*
  372.      * Convert jiffies to nanoseconds and separate with
  373.      * one divide.
  374.      */
  375.     __u64 nsec = (__u64)jiffies * TICK_NSEC;
  376.     value->tv_sec = div_long_long_rem(nsec, NSEC_PER_SEC, &value->tv_usec);
  377.     value->tv_usec /= NSEC_PER_USEC;
  378. }
  379.  
  380. /*
  381.  * Convert jiffies/jiffies_64 to clock_t and back.
  382.  */
  383. static inline clock_t jiffies_to_clock_t(long x)
  384. {
  385. #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
  386.     return x / (HZ / USER_HZ);
  387. #else
  388.     __u64 tmp = (__u64)x * TICK_NSEC;
  389.     do_div(tmp, (NSEC_PER_SEC / USER_HZ));
  390.     return (long)tmp;
  391. #endif
  392. }
  393.  
  394. static inline unsigned long clock_t_to_jiffies(unsigned long x)
  395. {
  396. #if (HZ % USER_HZ)==0
  397.     if (x >= ~0UL / (HZ / USER_HZ))
  398.         return ~0UL;
  399.     return x * (HZ / USER_HZ);
  400. #else
  401.     __u64 jif;
  402.  
  403.     /* Don't worry about loss of precision here .. */
  404.     if (x >= ~0UL / HZ * USER_HZ)
  405.         return ~0UL;
  406.  
  407.     /* .. but do try to contain it here */
  408.     jif = x * (__u64) HZ;
  409.     do_div(jif, USER_HZ);
  410.     return jif;
  411. #endif
  412. }
  413.  
  414. static inline __u64 jiffies_64_to_clock_t(__u64 x)
  415. {
  416. #if (TICK_NSEC % (NSEC_PER_SEC / USER_HZ)) == 0
  417.     do_div(x, HZ / USER_HZ);
  418. #else
  419.     /*
  420.      * There are better ways that don't overflow early,
  421.      * but even this doesn't overflow in hundreds of years
  422.      * in 64 bits, so..
  423.      */
  424.     x *= TICK_NSEC;
  425.     do_div(x, (NSEC_PER_SEC / USER_HZ));
  426. #endif
  427.     return x;
  428. }
  429.  
  430. static inline __u64 nsec_to_clock_t(__u64 x)
  431. {
  432. #if (NSEC_PER_SEC % USER_HZ) == 0
  433.     do_div(x, (NSEC_PER_SEC / USER_HZ));
  434. #elif (USER_HZ % 512) == 0
  435.     x *= USER_HZ/512;
  436.     do_div(x, (NSEC_PER_SEC / 512));
  437. #else
  438.     /*
  439.          * max relative error 5.7e-8 (1.8s per year) for USER_HZ <= 1024,
  440.          * overflow after 64.99 years.
  441.          * exact for HZ=60, 72, 90, 120, 144, 180, 300, 600, 900, ...
  442.          */
  443.     x *= 9;
  444.     do_div(x, (unsigned long)((9ull * NSEC_PER_SEC + (USER_HZ/2))
  445.                               / USER_HZ));
  446. #endif
  447.     return x;
  448. }
  449.  
  450. #endif
  451.